/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * File Name          : freertos.c
  * Description        : Code for freertos applications
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2024 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */

/* Includes ------------------------------------------------------------------*/
#include "FreeRTOS.h"
#include "task.h"
#include "main.h"
#include "cmsis_os.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
typedef struct {
    CAN_HandleTypeDef *hcan;
    uint32_t id;
    uint8_t len;
    uint8_t *buf_data;
}can_device_transmit_member;
/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN Variables */

/* USER CODE END Variables */
/* Definitions for defaultTask */
osThreadId_t defaultTaskHandle;
const osThreadAttr_t defaultTask_attributes = {
  .name = "defaultTask",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityNormal,
};
/* Definitions for LED_Task */
osThreadId_t LED_TaskHandle;
const osThreadAttr_t LED_Task_attributes = {
  .name = "LED_Task",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityBelowNormal,
};
/* Definitions for CAN1_Sending_Service */
osThreadId_t CAN1_Sending_ServiceHandle;
const osThreadAttr_t CAN1_Sending_Service_attributes = {
  .name = "CAN1_Sending_Service",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityHigh,
};
/* Definitions for CAN2_Sending_Service */
osThreadId_t CAN2_Sending_ServiceHandle;
const osThreadAttr_t CAN2_Sending_Service_attributes = {
  .name = "CAN2_Sending_Service",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityHigh,
};
/* Definitions for Motor_Test_Task */
osThreadId_t Motor_Test_TaskHandle;
const osThreadAttr_t Motor_Test_Task_attributes = {
  .name = "Motor_Test_Task",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityNormal,
};
/* Definitions for DJI_Motor_Service */
osThreadId_t DJI_Motor_ServiceHandle;
const osThreadAttr_t DJI_Motor_Service_attributes = {
  .name = "DJI_Motor_Service",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityHigh,
};
/* Definitions for LK_Motor_Service */
osThreadId_t LK_Motor_ServiceHandle;
const osThreadAttr_t LK_Motor_Service_attributes = {
  .name = "LK_Motor_Service",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityHigh,
};
/* Definitions for DM_Motor_Service */
osThreadId_t DM_Motor_ServiceHandle;
const osThreadAttr_t DM_Motor_Service_attributes = {
  .name = "DM_Motor_Service",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityHigh,
};
/* Definitions for RCReceiveTask */
osThreadId_t RCReceiveTaskHandle;
const osThreadAttr_t RCReceiveTask_attributes = {
  .name = "RCReceiveTask",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityHigh,
};
/* Definitions for Pitch_Task */
osThreadId_t Pitch_TaskHandle;
const osThreadAttr_t Pitch_Task_attributes = {
  .name = "Pitch_Task",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityNormal,
};
/* Definitions for Yaw_Task */
osThreadId_t Yaw_TaskHandle;
const osThreadAttr_t Yaw_Task_attributes = {
  .name = "Yaw_Task",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityNormal,
};
/* Definitions for Friction_Motor_Task */
osThreadId_t Friction_Motor_TaskHandle;
const osThreadAttr_t Friction_Motor_Task_attributes = {
  .name = "Friction_Motor_Task",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityNormal,
};
/* Definitions for Bullet_Feed_Task */
osThreadId_t Bullet_Feed_TaskHandle;
const osThreadAttr_t Bullet_Feed_Task_attributes = {
  .name = "Bullet_Feed_Task",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityNormal,
};
/* Definitions for Communicate_CAN_Task */
osThreadId_t Communicate_CAN_TaskHandle;
const osThreadAttr_t Communicate_CAN_Task_attributes = {
  .name = "Communicate_CAN_Task",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityHigh,
};
/* Definitions for Gyro_Task */
osThreadId_t Gyro_TaskHandle;
const osThreadAttr_t Gyro_Task_attributes = {
  .name = "Gyro_Task",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityNormal,
};
/* Definitions for Vision_Task */
osThreadId_t Vision_TaskHandle;
const osThreadAttr_t Vision_Task_attributes = {
  .name = "Vision_Task",
  .stack_size = 1024 * 4,
  .priority = (osPriority_t) osPriorityAboveNormal,
};
/* Definitions for Communicate_USB_Reiceive_Task */
osThreadId_t Communicate_USB_Reiceive_TaskHandle;
const osThreadAttr_t Communicate_USB_Reiceive_Task_attributes = {
  .name = "Communicate_USB_Reiceive_Task",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityAboveNormal,
};
/* Definitions for Communicate_USB_Transmit_Task */
osThreadId_t Communicate_USB_Transmit_TaskHandle;
const osThreadAttr_t Communicate_USB_Transmit_Task_attributes = {
  .name = "Communicate_USB_Transmit_Task",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityAboveNormal,
};
/* Definitions for Communicate_UART_Vision_Task */
osThreadId_t Communicate_UART_Vision_TaskHandle;
const osThreadAttr_t Communicate_UART_Vision_Task_attributes = {
  .name = "Communicate_UART_Vision_Task",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityAboveNormal,
};
/* Definitions for Auto_Patrol_Task */
osThreadId_t Auto_Patrol_TaskHandle;
const osThreadAttr_t Auto_Patrol_Task_attributes = {
  .name = "Auto_Patrol_Task",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityNormal,
};
/* Definitions for Semaphore_Cal_Task */
osThreadId_t Semaphore_Cal_TaskHandle;
const osThreadAttr_t Semaphore_Cal_Task_attributes = {
  .name = "Semaphore_Cal_Task",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityAboveNormal,
};
/* Definitions for Communicate_UART_Twins_Task */
osThreadId_t Communicate_UART_Twins_TaskHandle;
const osThreadAttr_t Communicate_UART_Twins_Task_attributes = {
  .name = "Communicate_UART_Twins_Task",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityAboveNormal,
};
/* Definitions for can1_send_fifo */
osMessageQueueId_t can1_send_fifoHandle;
const osMessageQueueAttr_t can1_send_fifo_attributes = {
  .name = "can1_send_fifo"
};
/* Definitions for can2_send_fifo */
osMessageQueueId_t can2_send_fifoHandle;
const osMessageQueueAttr_t can2_send_fifo_attributes = {
  .name = "can2_send_fifo"
};
/* Definitions for dr16UpdateBinarySem */
osSemaphoreId_t dr16UpdateBinarySemHandle;
const osSemaphoreAttr_t dr16UpdateBinarySem_attributes = {
  .name = "dr16UpdateBinarySem"
};
/* Definitions for LeftUSBDataUpdateBinarySem */
osSemaphoreId_t LeftUSBDataUpdateBinarySemHandle;
const osSemaphoreAttr_t LeftUSBDataUpdateBinarySem_attributes = {
  .name = "LeftUSBDataUpdateBinarySem"
};
/* Definitions for RightUSBDataUpdateBinarySem */
osSemaphoreId_t RightUSBDataUpdateBinarySemHandle;
const osSemaphoreAttr_t RightUSBDataUpdateBinarySem_attributes = {
  .name = "RightUSBDataUpdateBinarySem"
};
/* Definitions for VisionCalBinarySem */
osSemaphoreId_t VisionCalBinarySemHandle;
const osSemaphoreAttr_t VisionCalBinarySem_attributes = {
  .name = "VisionCalBinarySem"
};
/* Definitions for CAN1CountingSem */
osSemaphoreId_t CAN1CountingSemHandle;
const osSemaphoreAttr_t CAN1CountingSem_attributes = {
  .name = "CAN1CountingSem"
};
/* Definitions for CAN2CountingSem */
osSemaphoreId_t CAN2CountingSemHandle;
const osSemaphoreAttr_t CAN2CountingSem_attributes = {
  .name = "CAN2CountingSem"
};

/* Private function prototypes -----------------------------------------------*/
/* USER CODE BEGIN FunctionPrototypes */

/* USER CODE END FunctionPrototypes */

void StartDefaultTask(void *argument);
void LED_task(void *argument);
void can1_sending_service(void *argument);
void can2_sending_service(void *argument);
void motor_test_task(void *argument);
void DJI_motor_service(void *argument);
void LK_motor_service(void *argument);
void DM_motor_service(void *argument);
void rcReceiveTask(void *argument);
void pitch_task(void *argument);
void yaw_task(void *argument);
void friction_motor_task(void *argument);
void bullet_feed_task(void *argument);
void communicate_can_task(void *argument);
void GyroTask(void *argument);
void vision_task(void *argument);
void communicate_usb_receive_task(void *argument);
void communicate_usb_transmit_task(void *argument);
void communicate_uart_vision_task(void *argument);
void auto_patrol_task(void *argument);
void semaphore_cal_task(void *argument);
void communicate_uart_twins_task(void *argument);

extern void MX_USB_DEVICE_Init(void);
void MX_FREERTOS_Init(void); /* (MISRA C 2004 rule 8.1) */

/**
  * @brief  FreeRTOS initialization
  * @param  None
  * @retval None
  */
void MX_FREERTOS_Init(void) {
  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* USER CODE BEGIN RTOS_MUTEX */
  /* add mutexes, ... */
  /* USER CODE END RTOS_MUTEX */

  /* Create the semaphores(s) */
  /* creation of dr16UpdateBinarySem */
  dr16UpdateBinarySemHandle = osSemaphoreNew(1, 0, &dr16UpdateBinarySem_attributes);

  /* creation of LeftUSBDataUpdateBinarySem */
  LeftUSBDataUpdateBinarySemHandle = osSemaphoreNew(1, 0, &LeftUSBDataUpdateBinarySem_attributes);

  /* creation of RightUSBDataUpdateBinarySem */
  RightUSBDataUpdateBinarySemHandle = osSemaphoreNew(1, 0, &RightUSBDataUpdateBinarySem_attributes);

  /* creation of VisionCalBinarySem */
  VisionCalBinarySemHandle = osSemaphoreNew(1, 0, &VisionCalBinarySem_attributes);

  /* creation of CAN1CountingSem */
  CAN1CountingSemHandle = osSemaphoreNew(3, 3, &CAN1CountingSem_attributes);

  /* creation of CAN2CountingSem */
  CAN2CountingSemHandle = osSemaphoreNew(3, 3, &CAN2CountingSem_attributes);

  /* USER CODE BEGIN RTOS_SEMAPHORES */
  /* add semaphores, ... */
  /* USER CODE END RTOS_SEMAPHORES */

  /* USER CODE BEGIN RTOS_TIMERS */
  /* start timers, add new ones, ... */
  /* USER CODE END RTOS_TIMERS */

  /* Create the queue(s) */
  /* creation of can1_send_fifo */
  can1_send_fifoHandle = osMessageQueueNew (16, sizeof(can_device_transmit_member), &can1_send_fifo_attributes);

  /* creation of can2_send_fifo */
  can2_send_fifoHandle = osMessageQueueNew (16, sizeof(can_device_transmit_member), &can2_send_fifo_attributes);

  /* USER CODE BEGIN RTOS_QUEUES */
  /* add queues, ... */
  /* USER CODE END RTOS_QUEUES */

  /* Create the thread(s) */
  /* creation of defaultTask */
  defaultTaskHandle = osThreadNew(StartDefaultTask, NULL, &defaultTask_attributes);

  /* creation of LED_Task */
  LED_TaskHandle = osThreadNew(LED_task, NULL, &LED_Task_attributes);

  /* creation of CAN1_Sending_Service */
  CAN1_Sending_ServiceHandle = osThreadNew(can1_sending_service, NULL, &CAN1_Sending_Service_attributes);

  /* creation of CAN2_Sending_Service */
  CAN2_Sending_ServiceHandle = osThreadNew(can2_sending_service, NULL, &CAN2_Sending_Service_attributes);

  /* creation of Motor_Test_Task */
  Motor_Test_TaskHandle = osThreadNew(motor_test_task, NULL, &Motor_Test_Task_attributes);

  /* creation of DJI_Motor_Service */
  DJI_Motor_ServiceHandle = osThreadNew(DJI_motor_service, NULL, &DJI_Motor_Service_attributes);

  /* creation of LK_Motor_Service */
  LK_Motor_ServiceHandle = osThreadNew(LK_motor_service, NULL, &LK_Motor_Service_attributes);

  /* creation of DM_Motor_Service */
  DM_Motor_ServiceHandle = osThreadNew(DM_motor_service, NULL, &DM_Motor_Service_attributes);

  /* creation of RCReceiveTask */
  RCReceiveTaskHandle = osThreadNew(rcReceiveTask, NULL, &RCReceiveTask_attributes);

  /* creation of Pitch_Task */
  Pitch_TaskHandle = osThreadNew(pitch_task, NULL, &Pitch_Task_attributes);

  /* creation of Yaw_Task */
  Yaw_TaskHandle = osThreadNew(yaw_task, NULL, &Yaw_Task_attributes);

  /* creation of Friction_Motor_Task */
  Friction_Motor_TaskHandle = osThreadNew(friction_motor_task, NULL, &Friction_Motor_Task_attributes);

  /* creation of Bullet_Feed_Task */
  Bullet_Feed_TaskHandle = osThreadNew(bullet_feed_task, NULL, &Bullet_Feed_Task_attributes);

  /* creation of Communicate_CAN_Task */
  Communicate_CAN_TaskHandle = osThreadNew(communicate_can_task, NULL, &Communicate_CAN_Task_attributes);

  /* creation of Gyro_Task */
  Gyro_TaskHandle = osThreadNew(GyroTask, NULL, &Gyro_Task_attributes);

  /* creation of Vision_Task */
  Vision_TaskHandle = osThreadNew(vision_task, NULL, &Vision_Task_attributes);

  /* creation of Communicate_USB_Reiceive_Task */
  Communicate_USB_Reiceive_TaskHandle = osThreadNew(communicate_usb_receive_task, NULL, &Communicate_USB_Reiceive_Task_attributes);

  /* creation of Communicate_USB_Transmit_Task */
  Communicate_USB_Transmit_TaskHandle = osThreadNew(communicate_usb_transmit_task, NULL, &Communicate_USB_Transmit_Task_attributes);

  /* creation of Communicate_UART_Vision_Task */
  Communicate_UART_Vision_TaskHandle = osThreadNew(communicate_uart_vision_task, NULL, &Communicate_UART_Vision_Task_attributes);

  /* creation of Auto_Patrol_Task */
  Auto_Patrol_TaskHandle = osThreadNew(auto_patrol_task, NULL, &Auto_Patrol_Task_attributes);

  /* creation of Semaphore_Cal_Task */
  Semaphore_Cal_TaskHandle = osThreadNew(semaphore_cal_task, NULL, &Semaphore_Cal_Task_attributes);

  /* creation of Communicate_UART_Twins_Task */
  Communicate_UART_Twins_TaskHandle = osThreadNew(communicate_uart_twins_task, NULL, &Communicate_UART_Twins_Task_attributes);

  /* USER CODE BEGIN RTOS_THREADS */
  /* add threads, ... */
  /* USER CODE END RTOS_THREADS */

  /* USER CODE BEGIN RTOS_EVENTS */
  /* add events, ... */
  /* USER CODE END RTOS_EVENTS */

}

/* USER CODE BEGIN Header_StartDefaultTask */
/**
  * @brief  Function implementing the defaultTask thread.
  * @param  argument: Not used
  * @retval None
  */
/* USER CODE END Header_StartDefaultTask */
void StartDefaultTask(void *argument)
{
  /* init code for USB_DEVICE */
  MX_USB_DEVICE_Init();
  /* USER CODE BEGIN StartDefaultTask */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END StartDefaultTask */
}

/* USER CODE BEGIN Header_LED_task */
/**
* @brief Function implementing the LED_Task thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_LED_task */
__weak void LED_task(void *argument)
{
  /* USER CODE BEGIN LED_task */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END LED_task */
}

/* USER CODE BEGIN Header_can1_sending_service */
/**
* @brief Function implementing the CAN1_Sending_Service thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_can1_sending_service */
__weak void can1_sending_service(void *argument)
{
  /* USER CODE BEGIN can1_sending_service */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END can1_sending_service */
}

/* USER CODE BEGIN Header_can2_sending_service */
/**
* @brief Function implementing the CAN2_Sending_Service thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_can2_sending_service */
__weak void can2_sending_service(void *argument)
{
  /* USER CODE BEGIN can2_sending_service */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END can2_sending_service */
}

/* USER CODE BEGIN Header_motor_test_task */
/**
* @brief Function implementing the Motor_Test_Task thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_motor_test_task */
__weak void motor_test_task(void *argument)
{
  /* USER CODE BEGIN motor_test_task */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END motor_test_task */
}

/* USER CODE BEGIN Header_DJI_motor_service */
/**
* @brief Function implementing the DJI_Motor_Service thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_DJI_motor_service */
__weak void DJI_motor_service(void *argument)
{
  /* USER CODE BEGIN DJI_motor_service */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END DJI_motor_service */
}

/* USER CODE BEGIN Header_LK_motor_service */
/**
* @brief Function implementing the LK_Motor_Service thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_LK_motor_service */
__weak void LK_motor_service(void *argument)
{
  /* USER CODE BEGIN LK_motor_service */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END LK_motor_service */
}

/* USER CODE BEGIN Header_DM_motor_service */
/**
* @brief Function implementing the DM_Motor_Service thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_DM_motor_service */
__weak void DM_motor_service(void *argument)
{
  /* USER CODE BEGIN DM_motor_service */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END DM_motor_service */
}

/* USER CODE BEGIN Header_rcReceiveTask */
/**
* @brief Function implementing the RCReceiveTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_rcReceiveTask */
__weak void rcReceiveTask(void *argument)
{
  /* USER CODE BEGIN rcReceiveTask */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END rcReceiveTask */
}

/* USER CODE BEGIN Header_pitch_task */
/**
* @brief Function implementing the Pitch_Task thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_pitch_task */
__weak void pitch_task(void *argument)
{
  /* USER CODE BEGIN pitch_task */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END pitch_task */
}

/* USER CODE BEGIN Header_yaw_task */
/**
* @brief Function implementing the Yaw_Task thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_yaw_task */
__weak void yaw_task(void *argument)
{
  /* USER CODE BEGIN yaw_task */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END yaw_task */
}

/* USER CODE BEGIN Header_friction_motor_task */
/**
* @brief Function implementing the Friction_Motor_Task thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_friction_motor_task */
__weak void friction_motor_task(void *argument)
{
  /* USER CODE BEGIN friction_motor_task */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END friction_motor_task */
}

/* USER CODE BEGIN Header_bullet_feed_task */
/**
* @brief Function implementing the Bullet_Feed_Task thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_bullet_feed_task */
__weak void bullet_feed_task(void *argument)
{
  /* USER CODE BEGIN bullet_feed_task */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END bullet_feed_task */
}

/* USER CODE BEGIN Header_communicate_can_task */
/**
* @brief Function implementing the Communicate_CAN_Task thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_communicate_can_task */
__weak void communicate_can_task(void *argument)
{
  /* USER CODE BEGIN communicate_can_task */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END communicate_can_task */
}

/* USER CODE BEGIN Header_GyroTask */
/**
* @brief Function implementing the Gyro_Task thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_GyroTask */
__weak void GyroTask(void *argument)
{
  /* USER CODE BEGIN GyroTask */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END GyroTask */
}

/* USER CODE BEGIN Header_vision_task */
/**
* @brief Function implementing the Vision_Task thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_vision_task */
__weak void vision_task(void *argument)
{
  /* USER CODE BEGIN vision_task */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END vision_task */
}

/* USER CODE BEGIN Header_communicate_usb_receive_task */
/**
* @brief Function implementing the Communicate_USB_Reiceive_Task thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_communicate_usb_receive_task */
__weak void communicate_usb_receive_task(void *argument)
{
  /* USER CODE BEGIN communicate_usb_receive_task */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END communicate_usb_receive_task */
}

/* USER CODE BEGIN Header_communicate_usb_transmit_task */
/**
* @brief Function implementing the Communicate_USB_Transmit_Task thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_communicate_usb_transmit_task */
__weak void communicate_usb_transmit_task(void *argument)
{
  /* USER CODE BEGIN communicate_usb_transmit_task */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END communicate_usb_transmit_task */
}

/* USER CODE BEGIN Header_communicate_uart_vision_task */
/**
* @brief Function implementing the Communicate_UART_Vision_Task thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_communicate_uart_vision_task */
__weak void communicate_uart_vision_task(void *argument)
{
  /* USER CODE BEGIN communicate_uart_vision_task */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END communicate_uart_vision_task */
}

/* USER CODE BEGIN Header_auto_patrol_task */
/**
* @brief Function implementing the Auto_Patrol_Task thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_auto_patrol_task */
__weak void auto_patrol_task(void *argument)
{
  /* USER CODE BEGIN auto_patrol_task */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END auto_patrol_task */
}

/* USER CODE BEGIN Header_semaphore_cal_task */
/**
* @brief Function implementing the Semaphore_Cal_Task thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_semaphore_cal_task */
__weak void semaphore_cal_task(void *argument)
{
  /* USER CODE BEGIN semaphore_cal_task */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END semaphore_cal_task */
}

/* USER CODE BEGIN Header_communicate_uart_twins_task */
/**
* @brief Function implementing the Communicate_UART_Twins_Task thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_communicate_uart_twins_task */
__weak void communicate_uart_twins_task(void *argument)
{
  /* USER CODE BEGIN communicate_uart_twins_task */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END communicate_uart_twins_task */
}

/* Private application code --------------------------------------------------*/
/* USER CODE BEGIN Application */

/* USER CODE END Application */

